/*
 * Copyright (c) 2014,KJFrameForAndroid Open Source Project,张涛.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.dhwl.hsh.lib.utils;

import android.text.TextUtils;
import android.widget.EditText;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import java.util.regex.Pattern;

/**
 * 字符串操作工具包<br>
 * 
 * <b>创建时间</b> 2014-8-14
 * 
 * @author kymjs (https://github.com/kymjs)
 * @version 1.1
 */
public class StringUtils
{
    private final static Pattern emailer = Pattern.compile("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*");
    
    //    private final static Pattern phone = Pattern.compile("^((13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$");
    
    private final static Pattern phone = Pattern.compile("^((1[3,5,8][0-9])|(14[5,7])|(17[0,6,7,8]))\\d{8}$");
    
    /**
     * 判断给定字符串是否空白串 空白串是指由空格、制表符、回车符、换行符组成的字符串 若输入字符串为null或空字符串，返回true
     */
    public static boolean isEmpty(CharSequence input)
    {
        if (input == null || "".equals(input))
            return true;
        
        for (int i = 0; i < input.length(); i++)
        {
            char c = input.charAt(i);
            if (c != ' ' && c != '\t' && c != '\r' && c != '\n')
            {
                return false;
            }
        }
        return true;
    }
    
    /**
     * 判断是不是一个合法的电子邮件地址
     */
    public static boolean isEmail(CharSequence email)
    {
        if (isEmpty(email))
            return false;
        return emailer.matcher(email).matches();
    }
    
    /**
     * 判断是不是一个合法的手机号码
     */
    public static boolean isPhone(CharSequence phoneNum)
    {
        if (isEmpty(phoneNum))
            return false;
        return phone.matcher(phoneNum).matches();
    }
    
    /**
     * 字符串转整数
     * 
     * @param str
     * @param defValue
     * @return
     */
    public static int toInt(String str, int defValue)
    {
        try
        {
            return Integer.parseInt(str);
        }
        catch (Exception e)
        {
        }
        return defValue;
    }
    
    /**
     * 对象转整
     * 
     * @param obj
     * @return 转换异常返回 0
     */
    public static int toInt(Object obj)
    {
        if (obj == null)
            return 0;
        return toInt(obj.toString(), 0);
    }
    
    /**
     * String转long
     * 
     * @param obj
     * @return 转换异常返回 0
     */
    public static long toLong(String obj)
    {
        try
        {
            return Long.parseLong(obj);
        }
        catch (Exception e)
        {
        }
        return 0;
    }
    
    /**
     * String转double
     * 
     * @param obj
     * @return 转换异常返回 0
     */
    public static double toDouble(String obj)
    {
        try
        {
            return Double.parseDouble(obj);
        }
        catch (Exception e)
        {
        }
        return 0D;
    }
    
    /**
     * 字符串转布尔
     * 
     * @param b
     * @return 转换异常返回 false
     */
    public static boolean toBool(String b)
    {
        try
        {
            return Boolean.parseBoolean(b);
        }
        catch (Exception e)
        {
        }
        return false;
    }
    
    /**
     * 判断一个字符串是不是数字
     */
    public static boolean isNumber(CharSequence str)
    {
        try
        {
            Integer.parseInt(str.toString());
        }
        catch (Exception e)
        {
            return false;
        }
        return true;
    }
    
    /**
     * byte[]数组转换为16进制的字符串。
     * 
     * @param data
     *            要转换的字节数组。
     * @return 转换后的结果。
     */
    public static final String byteArrayToHexString(byte[] data)
    {
        StringBuilder sb = new StringBuilder(data.length * 2);
        for (byte b : data)
        {
            int v = b & 0xff;
            if (v < 16)
            {
                sb.append('0');
            }
            sb.append(Integer.toHexString(v));
        }
        return sb.toString().toUpperCase(Locale.getDefault());
    }
    
    /**
     * 16进制表示的字符串转换为字节数组。
     * 
     * @param s
     *            16进制表示的字符串
     * @return byte[] 字节数组
     */
    public static byte[] hexStringToByteArray(String s)
    {
        int len = s.length();
        byte[] d = new byte[len / 2];
        for (int i = 0; i < len; i += 2)
        {
            // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个进制字节
            d[i / 2] = (byte)((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
        }
        return d;
    }

    /**
     * MD5加密
     */
    public static String getMD5(String string)
    {
        byte[] hash;
        try
        {
            hash = MessageDigest.getInstance("MD5").digest(string.getBytes("UTF-8"));
        }
        catch (NoSuchAlgorithmException e)
        {
            throw new RuntimeException("Huh, MD5 should be supported?", e);
        }
        catch (UnsupportedEncodingException e)
        {
            throw new RuntimeException("Huh, UTF-8 should be supported?", e);
        }
        
        StringBuilder hex = new StringBuilder(hash.length * 2);
        for (byte b : hash)
        {
            if ((b & 0xFF) < 0x10)
                hex.append("0");
            hex.append(Integer.toHexString(b & 0xFF));
        }
        return hex.toString().toUpperCase();
    }
    
    //不能全是相同的数字或者字母（如：000000、111111、aaaaaa） 全部相同返回true
    public static boolean equalStr(String numOrStr)
    {
        boolean flag = true;
        char str = numOrStr.charAt(0);
        for (int i = 0; i < numOrStr.length(); i++)
        {
            if (str != numOrStr.charAt(i))
            {
                flag = false;
                break;
            }
        }
        return flag;
    }
    
    //不能是连续的数字--递增（如：123456、12345678）连续数字返回true
    public static boolean isOrderNumeric(String numOrStr)
    {
        boolean flag = true;//如果全是连续数字返回true
        boolean isNumeric = true;//如果全是数字返回true
        for (int i = 0; i < numOrStr.length(); i++)
        {
            if (!Character.isDigit(numOrStr.charAt(i)))
            {
                isNumeric = false;
                break;
            }
        }
        if (isNumeric)
        {//如果全是数字则执行是否连续数字判断
            for (int i = 0; i < numOrStr.length(); i++)
            {
                if (i > 0)
                {//判断如123456
                    int num = Integer.parseInt(numOrStr.charAt(i) + "");
                    int num_ = Integer.parseInt(numOrStr.charAt(i - 1) + "") + 1;
                    if (num != num_)
                    {
                        flag = false;
                        break;
                    }
                }
            }
        }
        else
        {
            flag = false;
        }
        return flag;
    }
    
    //不能是连续的数字--递减（如：987654、876543）连续数字返回true
    public static boolean isOrderNumeric_(String numOrStr)
    {
        boolean flag = true;//如果全是连续数字返回true
        boolean isNumeric = true;//如果全是数字返回true
        for (int i = 0; i < numOrStr.length(); i++)
        {
            if (!Character.isDigit(numOrStr.charAt(i)))
            {
                isNumeric = false;
                break;
            }
        }
        if (isNumeric)
        {//如果全是数字则执行是否连续数字判断
            for (int i = 0; i < numOrStr.length(); i++)
            {
                if (i > 0)
                {//判断如654321
                    int num = Integer.parseInt(numOrStr.charAt(i) + "");
                    int num_ = Integer.parseInt(numOrStr.charAt(i - 1) + "") - 1;
                    if (num != num_)
                    {
                        flag = false;
                        break;
                    }
                }
            }
        }
        else
        {
            flag = false;
        }
        return flag;
    }
    
    /**
     * 格式化商品价格,转换为 0.00 格式
     * @param price
     * @return
     */
    public static String getPrice(double price)
    {
        return getPrice(String.valueOf(price));
    }
    
    /**
     * 格式化商品价格,转换为 0.00 格式
     * @param price
     * @return
     */
    public static String getPrice(String price)
    {
        //空字符
        if (StringUtils.isEmpty(price))
        {
            return "0.00";
        }
        
        //非整数或小数
        if (!(isDigital(price) || isDouble(price)))
        {
            return price;
        }
        
        int index = price.indexOf('.');
        
        //无小数部分
        if (-1 == index)
        {
            return price + ".00";
        }
        
        //整数部分
        String prefix = price.substring(0, index);
        
        //小数部分
        String postfix = price.substring(index + 1);
        
        StringBuilder result = new StringBuilder();
        
        //小数部分长度
        switch (postfix.length())
        {
        //无小数部分
            case 0:
                result.append(prefix).append(".00");
                break;
            //只有一位小数
            case 1:
                result.append(prefix).append('.').append(postfix).append('0');
                break;
            //两位小数
            case 2:
                result.append(prefix).append('.').append(postfix);
                break;
            //三位或以上小数,需要进行四舍五入
            default:
                String t = String.valueOf(Math.round(Double.parseDouble(postfix.substring(0, 3)) / 10));
                //不足两位补0
                if (t.length() < 2)
                {
                    t = t + "0";
                }
                //进位
                else if (t.length() > 2)
                {
                    prefix = String.valueOf(Integer.parseInt(prefix) + 1);
                    t = t.substring(1);
                }
                
                //拼接整数与小数部分
                result.append(prefix).append('.').append(String.valueOf(t));
                break;
        }
        return result.toString();
    }
    
    /**
     * 判断字符是否带小数
     * @param str
     * @return
     */
    public static boolean isDouble(String str)
    {
        if (TextUtils.isEmpty(str))
        {
            return false;
        }
        if (isDigital(str))
        {
            return true;
        }
        return str.matches("(-)?\\d+\\.\\d+");
    }
    
    /**
     * 判断字符是否数字
     * @param str
     * @return
     */
    public static boolean isDigital(String str)
    {
        if (TextUtils.isEmpty(str))
        {
            return false;
        }
        return str.matches("(-)?\\d+");
    }
    
    /** <混淆后的手机号码>
     * @param phoneNumber
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static String getConfusePhone(String phoneNumber)
    {
        if (isPhone(phoneNumber))
        {
            return phoneNumber.substring(0, 3) + "****"
                + phoneNumber.substring(phoneNumber.length() - 4, phoneNumber.length());
        }
        return phoneNumber;
    }

    /**
     * 判断edittext是否null
     */
    public static String checkEditText(EditText editText) {
        if (editText != null && editText.getText() != null
                && !(editText.getText().toString().trim().equals(""))) {
            return editText.getText().toString().trim();
        } else {
            return "";
        }
    }
    
}
